package nsu.edu.zsq.util;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import nsu.edu.zsq.bean.SchMajor;
import nsu.edu.zsq.bean.SchOrg;
import nsu.edu.zsq.param.SchOrgParam;
import nsu.edu.zsq.param.SchOrgWithMajor;

/** 
* Description: SchOrg的工具类<br>
*/
public class SchOrgUtil {
    
    /**
     * 根据parentOrgId,层次结构排序。<br>
     * 下一个组织是上一个组织的子组织（类似效果：id-parenOrgId:1-0,2-1,4-2,3-1,5-0）
     * @param schOrgs 未进行排序算法的原组织列表
     * @return List<SchOrg> sortedSchOrgs带有层级结构的组织列表
     */
    public static List<SchOrg> sortByParentOrgId(List<SchOrg> schOrgs) {
        if (schOrgs == null || schOrgs.size() <= 0) {
            return schOrgs;
        }
        List<SchOrg> sortedSchOrgs = new ArrayList<SchOrg>();
        Iterator<SchOrg> iterator = schOrgs.iterator();
        while(iterator.hasNext()) {
            SchOrg schOrg = iterator.next();
            // 1.添加一级组织
            if (schOrg.getParentOrgId() == 0) {
                sortedSchOrgs.add(schOrg);
                iterator.remove();
                int i = 1;
                // 2.深度遍历：添加当前组织的子组织
                sort(schOrgs, sortedSchOrgs, i);
                // 3.向前回溯
                while (++i <= sortedSchOrgs.size()) {
                    // 算法优化，即遇到一级组织后不需要继续向前回溯了
                    if (sortedSchOrgs.get(sortedSchOrgs.size() - i + 1).getParentOrgId() == 0) {
                        break;
                    }
                    sort(schOrgs, sortedSchOrgs, i);
                }
                // 防止“java.util.ConcurrentModificationException”异常，即获取最新的Iterator
                iterator = schOrgs.iterator();
            }
        }
        return sortedSchOrgs;
    }
    
    /**
     * 深度遍历，添加当前组织的子组织
     * @param schOrgs 未进行排序算法的原组织链表
     * @param sortedSchOrgs 已经排序过的组织链表
     * @param i 位置标识号
     */
    private static void sort(List<SchOrg> schOrgs, List<SchOrg> sortedSchOrgs, int i) {
        SchOrg lastSchOrg = sortedSchOrgs.get(sortedSchOrgs.size() - i);
        Iterator<SchOrg> iterator = schOrgs.iterator();
        while(iterator.hasNext()) {
            SchOrg schOrg = iterator.next();
            if (schOrg.getParentOrgId() == lastSchOrg.getId()) {
                sortedSchOrgs.add(schOrg);
                iterator.remove();
                sort(schOrgs, sortedSchOrgs, 1);
                // 防止“java.util.ConcurrentModificationException”异常，即获取最新的Iterator
                iterator = schOrgs.iterator();
            }
        }
    }
    
    /**
     * 为每个组织计算其层级level，并设置hasChildren属性
     * @param sortedSchOrgs 已经有层级结构的组织链表列表
     * @return List<SchOrg> soredSchOrgsWithLevel带有层级的组织列表
     */
    public static List<SchOrg> setSchOrgLevel(List<SchOrg> sortedSchOrgs) {
        int level = 0;
        /**
         * i指针指向当前需要计算层级的组织位置
         * j指针辅助
         */
        for (int i = sortedSchOrgs.size() - 1; i >= 0; i--) {
            int parentOrgId = sortedSchOrgs.get(i).getParentOrgId();
            for (int j = i - 1; j >= 0; j--) {
                if (sortedSchOrgs.get(i).getParentOrgId() == 0) {
                    sortedSchOrgs.get(i).setLevel(0);
                    break;
                }
                if (parentOrgId == sortedSchOrgs.get(j).getId()) {
                    level++;
                    parentOrgId = sortedSchOrgs.get(j).getParentOrgId();
                    // 则j位置的组织拥有子组织
                    sortedSchOrgs.get(j).setHasChildren(true);
                }
                if (sortedSchOrgs.get(j).getParentOrgId() == 0) {
                    break;
                }
            }
            sortedSchOrgs.get(i).setLevel(level);
            level = 0;
        }
        return sortedSchOrgs;
    }
    
    /**
     * 将院系列表转换为带有子院系的树结构列表
     * @param listSchOrgParam 院系列表
     * @return List<SchOrgParam>
     */
    public static List<SchOrgParam> schOrgParamToTree(List<SchOrgParam> listSchOrgParam) {
        List<SchOrgParam> schOrgParamTree = new ArrayList<>();
        Iterator<SchOrgParam> listSchOrgParamIterator = listSchOrgParam.iterator();
        // 一级院系的父id
        int rootId = 0;
        while (listSchOrgParamIterator.hasNext()) {
            // 将一级院系（即根节点）加入schOrgParamTree
            SchOrgParam schOrgParam = listSchOrgParamIterator.next();
            if (schOrgParam.getParentOrgId() == rootId) {
                schOrgParamTree.add(schOrgParam);
                listSchOrgParamIterator.remove();
            }
        }
        // 遍历添加子院系
        transformSchOrgParamTree(schOrgParamTree, listSchOrgParam);
        return schOrgParamTree;
    }
    
    /**
     * 为每个根院系遍历添加子院系
     * @param listRootSchOrgParam 根院系
     * @param listSchOrgParam 所有院系列表
     */
    private static void transformSchOrgParamTree(List<SchOrgParam> listRootSchOrgParam, List<SchOrgParam> listSchOrgParam) {
        if (listSchOrgParam == null || listSchOrgParam.size() <= 0) {
            return;
        }
        for (SchOrgParam rootSchOrgParam : listRootSchOrgParam) {
            // 根院系加入子院系
            Iterator<SchOrgParam> listSchOrgParamIterator = listSchOrgParam.iterator();
            while (listSchOrgParamIterator.hasNext()) {
                SchOrgParam schOrgParam = listSchOrgParamIterator.next();
                if (schOrgParam.getParentOrgId() == rootSchOrgParam.getId()) {
                    rootSchOrgParam.getChildren().add(schOrgParam);
                    listSchOrgParamIterator.remove();
                }
            }
            // 子院系再加入其子院系
            if (rootSchOrgParam.getChildren() != null && rootSchOrgParam.getChildren().size() > 0) {
                transformSchOrgParamTree(rootSchOrgParam.getChildren(), listSchOrgParam);
            }
        }
    }
    
    /**
     * 将专业列表和院系列表转换为tree数据，一级节点为院系，二级为专业(只将有专业的院系显示出来)
     * @param listSchMajor 专业列表
     * @param listSchOrg 院系列表
     * @return String tree结构的Json数据
     */
    public static String schOrgWithMajorToTree(List<SchMajor> listSchMajor, List<SchOrg> listSchOrg) {
        List<SchOrgWithMajor> schOrgWithMajorTree = new ArrayList<SchOrgWithMajor>();
        // 1.添加tree的一级节点：院系
        for (SchOrg schOrg : listSchOrg) {
            boolean flag = false;
            // 院系
            SchOrgWithMajor schOrgWithMajor = new SchOrgWithMajor();
            // 院系的子节点，即专业
            List<SchOrgWithMajor> schMajorChildren = new ArrayList<SchOrgWithMajor>();
            Iterator<SchMajor> iterator = listSchMajor.iterator();
            while (iterator.hasNext()) {
                // 专业
                SchOrgWithMajor schOrgWithMajor2 = new SchOrgWithMajor();
                SchMajor schMajor = iterator.next();
                if (schOrg.getId() == schMajor.getOrgId()) {
                    if (!flag) {
                        // 设置院系信息(只需要设置一次即可)
                        schOrgWithMajor.setMajorNo("0");
                        schOrgWithMajor.setName(schOrg.getOrgName());
                    }
                    
                    // 设置tree的二级节点：专业
                    schOrgWithMajor2.setMajorNo(schMajor.getMajorNo());
                    schOrgWithMajor2.setName(schMajor.getMajorName());
                    schMajorChildren.add(schOrgWithMajor2);
                    flag = true;
                }
            }
            if (flag) {
                schOrgWithMajor.setChildren(schMajorChildren);
                schOrgWithMajorTree.add(schOrgWithMajor);
            }
        }
        return JsonMapper.obj2String(schOrgWithMajorTree);
    }
}
